System and method for customizing the identification of application or content type

ABSTRACT

Expertise, for performing classification of a type of network traffic, can be encapsulated in a module. A set of modules, as currently available to a traffic controller, can be referred to as a collection. Programming language constructs are introduced that facilitate the writing of modules customized to identify network traffic that is peculiar to a particular user, or to a relatively small group of users. An example programming language, based on Tcl, is introduced. A key aspect is event-driven programming, and the “when” command construct is introduced. Three important event types, that can trigger a “when” command, are CLIENT_DATA, SERVER_DATA, and RULE_INIT. Another key aspect is an ability to keep state information between events. Constructs for intra-session, intra-module, and global state are introduced. A module can be blocked from executing more than once for a session. Successful execution of a module can be specified by a “match” statement.

CROSS REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.13/842,372, filed on Mar. 15, 2013, entitled “System and Method forCustomizing the Identification of Application or Content Type”, which isrelated to the following U.S. patent application(s): “System and Methodof Updating Modules for Application or Content Identification,” filed onMar. 15, 2013, having inventor(s) Dennis Isao Oshiba, application. Ser.No. 13/842,196, which are herein incorporated by reference in theirentirety for all purposes.

TECHNICAL FIELD

The present invention relates generally to the determination of whethera session carries an identifiable type of network traffic, and moreparticularly to updating modules for performing such identification orto the creation of customized modules for such identification.

BACKGROUND

The importance and complexity of computer networks (such as theInternet) has grown exponentially over the past two decades, and suchgrowth is likely to continue in the foreseeable future. As their sizeand complexity have increased, various types of traffic controllers, forthe management of computer networks, have also found increasingimportance.

Traffic controllers are known to be useful for a variety of purposes,including, but not limited to, bandwidth management. As part ofperforming their function, it is also known to be useful to identify thetypes of sessions that such traffic controllers are handling. Forexample, it can be useful to know that a session is being utilized by aparticular type of application software (where “application software”can also be referred to herein, more simply, as an application). Asanother example, it can be useful to know that a session is carrying aparticular type of content.

The techniques for identifying a particular type of network traffic canbe encapsulated in a subsystem referred to herein as a “module.” The setof modules currently available to a traffic controller, for purposes oftraffic type identification, can be referred to herein as a“collection.” A collection may be organized as a “library” of modules,or according to any other suitable form of organization.

Such collections are known to require updating for a variety of purposesand in a variety of ways. For example, an algorithm, by which a moduleidentifies whether a session is being used by a particular type ofnetwork traffic, may be improved. In this case, an update of the modulemay be needed. As another example, a type of network traffic, notpreviously identified, can have an algorithm for its identificationdeveloped. This algorithm can be added, as an entirely new module, to acollection. Conversely, a type of network traffic, that is beingidentified by a module, may become obsolete. Thus, the module, foridentification of this type of traffic, may need to be removed from acollection.

It would be desirable to improve the process by which a pre-existing (or“old”) collection of modules is replaced with an updated (or “new”)collection.

Traffic controllers are typically mass-produced, to serve the needs of alarge group of customers. As such, traffic controllers are often soldwith module collections that only identify types of network traffic thatoccur very frequently, across many types of customers.

It would be desirable to improve the ability of a single customer, or arelatively small group of customers, to have prepared modules thatidentify less-frequent types of traffic. For example, a customer may bethe only organization to use its particular in-house software.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, that are incorporated in and constitute apart of this specification, illustrate several embodiments of theinvention and, together with the description, serve to explain theprinciples of the invention:

FIG. 1A depicts several clients (Client 110, Client 111, . . . Client112) that exchange packets with a sever (e.g., Data Center 130).

FIG. 1B shows three important event types, that can trigger aclassification module.

FIG. 2A shows an example interior structure for a traffic controller(such as Traffic Controller 120).

FIG. 2B is the same as FIG. 2A, except for having up to two locationsfor storing CM collections and having a different Session Table 250.

FIG. 2C shows an example internal structure for a CM collection such as201.

FIG. 3A illustrates example interior structures, for Session Table 210and Action Table 220.

FIG. 3B shows an example internal realization of Rule Table 230.

FIG. 3C depicts an example internal realization of State Tables 240.

FIG. 4A illustrates internal realization of Session Table 250.

FIG. 4B is the same as FIG. 3B, except the use of L4 Criteria field 231is replaced with referencing CM_ID_1 in L7 Criteria field 232.

FIGS. 5A-5C depict, in pseudo-code form, an example control procedure bywhich a Control Engine 200 can implement certain constructs.

FIG. 6A presents, as part of depicting a pseudo-coded process, a numberof globally persistent variables that are to be allocated andinitialized.

FIG. 6B depicts a COLLECTION_LOADED procedure, that is activated eachtime an updated CM collection is loaded.

FIGS. 6C-6G depict a collection-switching version of the PACKET_RECEIVEDprocedure, that is a modified form of the procedure shown in FIGS.5A-5B.

DETAILED DESCRIPTION

Reference will now be made in detail to various embodiments of theinvention, examples of which are illustrated in the accompanyingdrawings. Wherever possible, the same reference numbers will be usedthroughout the drawings to refer to the same or like parts.

Please refer to Section 5 below (“Glossary of Selected Terms”) for thedefinition of selected terms used below.

Table of Contents to Detailed Description 1 Introduction 2Classification Module Language 3 Multiple Collections 4 AdditionalInformation 4.1 Computing Equipment 5 Glossary of Selected Terms 1Introduction

The term “session,” as utilized herein, is understood very broadly (seedefinition in below Glossary of Selected Terms).

With respect to the network traffic that is carried by a session, thedetermination of its type can be referred to herein as “classification.”The expertise for performing a i classification can be encapsulated in amodule. The term “module” as utilized herein is (as with a session) alsounderstood very broadly (see definition in below Glossary of SelectedTerms).

A module for performing classification can be referred to herein as a“classification module” or CM. The inventive techniques presented hereinfocus on two) main areas:

Improving the process by which a CM collection, as utilized by a trafficcontroller, is updated.

Enhancing the ability of a user, or small groups of users, to createclassification modules customized to the particular types of networktraffic they handle (please see Glossary for definition of “user”).

With respect to the latter, of the two above-listed areas, certainprogramming language constructs are herein introduced. Incorporationinto a programming language, of one or more of these constructs, isdefined to result in a programming language referred to herein as a“Classification Module Language” or CIVIL. A CML facilitates the)writing of a CM customized to identify network traffic that is peculiarto a particular user, or to a relatively small group of users. Forexample, a company may have one or more in-house applications that areunique to that company.

The example CIVIL presented herein is called CML_Tcl. (For acorrespondence, between CML_Tcl and products of A10 NETWORKS, see thebelow Glossary of Selected Terms.) CML_Tcl is based upon the “Tel”programming language (please see Glossary for further identification ofTel). Also, the pseudo-code presented herein, used to illustrate exampleimplementations of some CIVIL constructs, is itself loosely based uponCIVIL Tcl and uses some CML constructs. In particular, a key constructof a CIVIL is that it is event driven. The syntax presented herein, forhaving code event driven, is the same for both CIVIL Tcl and thepseudo-code. A “when” command is used, that has the following structure:

when EVENTJMAME {<code to execute upon event>}The above “when” statement is triggered by an event generically referredto as EVENT_NAME (the convention is followed herein of naming an eventin all capitals). The entire body of the “when” can also be referred toherein as the “EVENT_NAME procedure.”

An example network environment, for a traffic controller (TrafficController 120), is shown in FIG. 1A. FIG. 1A depicts several clients(Client 110, Client 111, . . . Client 112) that exchange packets with aserver (e.g., Data Center 130). Data Center 130 can comprise, forexample, the following (not shown) equipment: an array of largelyhomogeneous servers (e.g., a server “farm”), all of which receive workrequests through a common server load balancer. For clients outside theData Center, the server load balancer can provide a consolidated IPaddress (a.k.a. a Virtual IP or VIP). Clients send their requests to theVIP and responses, from Data Center 130, appear to have the VIP as theirsource IP address. Data Center 130 is shown as being administered by aprivate entity (e.g., a “Company”) and connects to a private network 101by a link 155. Traffic Controller 120 couples private network 101 to theInternet (shown as Internet 100). Traffic Controller 120 connects to theprivate network by a link 154, and to the Internet by a link 153. TheTraffic Controller 120 can be utilized for any suitable purpose,including, but not limited to, bandwidth management. Each of the clientsconnects to the Internet by a corresponding link (e.g., each of clientsClient 110, Client 111, . . . Client 112 has, corresponding to it, Link150, Link 151, . . . Link 152).

An example interior structure for a traffic controller (such as TrafficController 120) is shown in FIG. 2A. Traffic Controller 120 is shown asincluding a Control Engine 200. By controlling a Network Interface 240,Control Engine 200 can control the transmission and receipt of packets,between clients and servers. For purposes of determining the type oftraffic conducted by a session, Control Engine 200 is shown as havingloaded a collection of classification modules called CM Collection 201.The term “loaded,” as utilized herein, is understood very broadly (seedefinition in below Glossary of Selected Terms). Control Engine 200 isshown as controlling links 153, 154, as well as any other number oflinks, represented by the ellipses and link 241.

When not classifying sessions, the operation of Traffic Controller 120can be understood by reference to its Session Table 210 and Action Table220. Example interior structures, for Session Table 210 and Action Table220, are shown in FIG. 3A.

A session can often be distinguished, from other sessions, by its valuesfor the following 5-tuple:

source IP

source Port

destination IP

destination Port.

protocol-used, and (if applicable) its current state

However identified, each session is typically represented by its owninstance of a data structure, referred to herein as a “Session Record.”FIG. 3A shows each Session Record represented by an entry in a SessionTable 210. Each Session Record is shown as comprising the followingfields:

Session ID (or SID) 212: a unique identifier (such as a unique number)that distinguishes each entry, of the Session Table, from all its otherentries.

5-tuple 213: the 5-tuple discussed above, relating to the uniqueidentification of each session.

Traffic ID's (or TID's) 214, 215, 216: Depending upon how the traffic ofa session is classified (a process to be discussed further in thefollowing section), one or more TID's may be added. While only threesuch TID's are shown, any suitable number can be allocated to eachSession Record.

As an example, row 370 of Session Table 210 depicts a Session Recordwith the following values:

SID=“SID_1”

5-tuple=sIP dIP sP dP ptcl

TID's=“TID_1,” “TID_2.”

The TID's assigned to a session can be used, as follows, to effect atraffic controller's handling of the packets it receives:

Each time a packet p_1 is received, its session s_1 is determined.

The Session Record, for the identified session, is accessed.

If necessary, the 5-tuple for s_1 is updated. Typically, this involvesupdating the state of the protocol.

The TID's, for the identified Session Record, are accessed and appliedto an Action Table, such as Action Table 220 of FIG. 3A.

Each action retrieved is applied to the processing of the currentpacket. The processing of a packet, in accordance with a particularcourse of action, can also be referred to as a “policy.” Even ifspecific TID's have not yet been assigned to the Session Record of asession, as a result of classification modules, its packets can still beprocessed according to a default policy (or policies).

For example, suppose the operator of a traffic controller is a companycalled “CableTV Inc.,” that provides cable television service. AssumeCableTV Inc. has its own in-house application software called“CableTV_1.” Further suppose that the company has at least the twofollowing goals regarding its software:

It wishes to give usage of its software top priority over its networks.

It wishes to monitor usage of the software.

Action Table 220 shows two example entries, 375 and 376, that have beenconfigured by CableTV Inc. (These entries can be configured by CableTVInc. using any suitable interface, as provided by the producer oftraffic controller 120. Suitable interfaces can include, but are notlimited to, a Graphical User Interface or Command Line Interface.) Inaccordance with action 375, each packet identified as type TID_1 ishandled with a quality of service level called “QoS_1” (which we willassume, for CableTV Inc., represents its highest priority networkusage). In accordance with action 376, each packet identified as typeTID_2 is identified as “CableTV_1” (which we will assume, for CableTVInc., means the packet will be reported as being associated withapplication CableTV_1).

Thus, if sessions with CableTV Inc.'s data center that utilize CableTV_1can be classified with TID's TID_1 and TID_2, the company's goals, forusage of this particular item of in-house software, can be realized.

The specification, for how sessions are to be classified, can beorganized as a collection of classification rules. In general, aclassification rule is comprised of the following two main sections:

trigger conditions, and

an identification to added to a session if the trigger conditions aremet

Each rule can be represented as an instance of a data structure,referred to herein as a “Rule Record” Each Rule Record can be stored asan entry in a Rule Table, such as Rule Table 230 of FIG. 2A. An exampleinternal realization of Rule Table 230 is shown in FIG. 3B. The triggerconditions are specified by the following two fields:

L4 Criteria 231: Although referred to as “L4 Criteria,” this is just ashorthand, and it should be understood that this field can contain anycombination of criteria at L4 or lower. It is often possible to classifya session based upon an examination of data from its first packet, wheresuch data has been drawn from fields of the packet that operate at L4 orlower.

L7 Criteria 232: Although referred to as “L7 Criteria,” this is just ashorthand, and it should be understood that this field can require anycombination of criteria from among the levels L7 or lower. If above L4information is needed to identify a session, or if state must be keptacross multiple packets, it is appropriate to use this field rather than231. Field 232 of a Rule Record can specify such criteria by containinga “classification module ID” or CMID (explained further below).

The identification to be added, if the rule's trigger conditions aresatisfied, is specified by TID field 233.

For the time being, we will assume that the goals of CableTV Inc. can bemet with rules that only use criteria of <L4. FIG. 3B shows two exampleclassification rules, 380 and 381, both of which rely upon criteria ofL4 or lower. For simplicity of exposition, the particular criteria ofeach of rules 380 and 381 is represented symbolically. The criteria ofrules 380 and 381 are the same, and are represented by “L4 criteria_1.”Anyone of ordinary skill in this area will readily appreciate that L4criteria_1 can represent value (and/or value range) specifications forsuch packet characteristics as:

source IP address

destination IP address

source Port

destination Port

MAC address

(and any further appropriate criteria)

Example session 370, of Session Table 210 of FIG. 3A, is assumed to havemet the criteria of rules 380 and 381. As a result of the priortriggering of classification rules, this session, identified by SIDSID_1, is shown as already having been assigned TID's TID_1 and TID_2.

The specification of classification rules by a user, such as thespecification of rules 380 and 381, can be accomplished using anysuitable interface, as provided by the producer of traffic controller120. As already introduced above, suitable interfaces can include, butare not limited to, a Graphical User Interface (or GUI) or Command LineInterface (or CLI).

2 Classification Module Language

The example presented in the previous section, of CableTV Inc. takingcertain actions with regard to packets generated by use of its in-housesoftware CableTV_1, assumes that a session (i.e., the session with SID“SID_1”) was able to be classified with criteria<L4. If that is not thecase, and criteria above L4 are needed, under conventional scenarios,CableTV Inc. may not have attractive options.

As has been discussed above, traffic controllers are typicallymass-produced, to serve the needs of a large group of customers. Assuch, traffic controllers are often sold with classification modulecollections (or CM collections) only designed to identify traffic typesoccurring very frequently, across many types of customers. Thus, it isunlikely the traffic-controller provider has a classification moduledesigned specifically for CableTV Inc.'s in-house software.

Conventional options for CableTV Inc. typically include the following:

Hiring the provider of the traffic controller to perform full-customprogramming, resulting in a classification module that is added to CMcollection 201. This approach requires minimum technical expertise fromthe user but (especially for specialized software with a limited enduser base) can be cost prohibitive.

The user performs full-custom programming, and produces a classificationmodule. This approach minimizes monetary cost to the user, but requiresa very high level of technical skill.

This section presents certain programming language constructs that makeit easier for a traffic controller user, such as CableTV Inc., to writeits own classification module. As discussed above, a programminglanguage with one or more of these constructs is referred to herein as aClassification Module Language or CML. As such, a CIVIL provides a kindof midpoint, between the levels of technical skill required by the twoabove-described conventional options.

Continuing with the example of CableTV Inc., we will assume they have atleast two different types of users of its data center and networks:

administrative users; and

end users.

Relative to the end-users, the administrative users can be expected tobe much more technologically knowledgeable. Administrative userstypically have responsibilities that include the following:

Design and maintenance of CableTV Inc.'s data center.

Design and maintenance of CableTV Inc.'s network, that can include suchequipment as a traffic controller.

In contrast, end-users can often include persons with little or notechnical background. Such end-users use software (through clients suchas 110, 111, . . . 112), such as CableTV_1, as a kind of service,expecting the service to be available whenever needed. (Depending uponthe user and/or situation, an administrative user and end-user can bethe same person.)

In general, a CIVIL is intended for use by administrative users.

FIGS. 5A-5C depict, in pseudo-code form, an example control procedure bywhich a Control Engine 200 can implement certain constructs, that havebeen added to the Tel programming language, and that result in what hasbeen called above a CML_Tcl. As was discussed above, a key construct ofa CIVIL is that it is event driven, and an example syntax for thisconstruct (also introduced above) is the “when” command.

As was also discussed above, the pseudo-code presented herein is itselfloosely based on CML_Tcl. For example, it can be seen that the entirecontrol procedure of FIGS. 5A-5C is wrapped within a pseudo “when”statement:

A “when” begins at line 1, FIG. 5A, triggering from an event called“PACKET_RECEIVED,” and ends with the right bracket of line 5, FIG. 5C.

A PACKET_RECEIVED event is defined as follows: it occurs whenever atraffic controller receives a packet, of a type within its scope ofcontrol, regardless of the packet's direction or purpose.

The just-received packet, that constitutes the latest PACKET_RECEIVEDevent, is referenced in the body of the “when” by the variable p_1.

In accordance with the convention discussed above, the entire “when”statement is also be referred to herein as the “PACKET_RECEIVEDprocedure.”

The first action the PACKET_RECEIVED procedure performs is referred toherein as “session-detection.” (In the pseudo-code, session-detection isperformed by the call to procedure session_detection, line 10, FIG. 5A.)Session-detection is defined herein as follows: determining, when apacket p_1 is received, whether p_1 is either:

the start of a new session (in the case of FIG. 5A, line 10, indicatedby the setting of the variable new_session to true); or

a continuation of a pre-existing session (in the case of FIG. 5A,indicated by the setting of the variable new_session to false).

Regardless of whether p_1 is the start or continuation of a session,session_detection causes s_1 to refer to such session. It is also usefulto determine whether the just-received packet is the final packet of asession. In the case of session_detection, this is indicated by thesetting of the variable s_overto true (line 10).

The beginning of a new session can be identified in any suitable way. Insome cases, it can be identified by extracting the following 5-tuplefrom p_1:

source IP

source Port

destination IP

destination Port.

protocol-used, and (if applicable) its current state

The extracted 5-tuple can then be compared to each Session Record ofSession Table 210. If no match is found, to a pre-existing SessionRecord, a new Session Record is created and added to the Session Table.

Before p_1 is processed according to the Traffic ID's of its SessionRecord, p_1 itself is first subjected to classification, since it couldeffect the Traffic ID's. At least some of the classification modules ofCM collection 201 are assumed to be written in a CIVIL, such as CML Tel.

In addition to being event driven, another key aspect of a CIVIL are thetypes of events by which it can be triggered. Three important eventtypes, that can trigger a classification module, are shown in FIG. 1B.The types are:

CLIENT_DATA: a “CLIENT_DATA” event occurs when a packet, on its way froma client to a server, is intercepted by a traffic controller. FIG. 1Bshows an example CLIENT_DATA event 140.

SERVER_DATA: a “SERVER_DATA” event occurs when a packet, on its way froma server to a client, is intercepted by a traffic controller. FIG. 1Bshows an example SERVER_DATA event 141.

RULEJNIT event: a “RULEJNIT” event occurs when the first packet of asession is intercepted by a traffic controller, regardless of whether itis a CLIENT DATA or SERVER DATA event.

Another key aspect of a CIVIL is that it be capable of keeping stateinformation, at least between the events of a single session. This isbecause identification of the type of traffic carried by the session canrequire the examination of multiple packets. A primary function of theRULEJNIT event is to initialize such state. At least three differenttypes of state can be defined:

intra-session persistent state: The CML only guarantees the persistenceof the state within the existence of a single session.

intra-module persistent state: The CML guarantees persistence of statebetween sessions, so long as the sessions use the same classificationmodule (as indicated by common CMID).

globally persistent state: The CML guarantees persistence of statebetween all sessions.

Focused-upon herein is intra-session persistent state, since that is thetype of state most commonly used. An example syntax for declaring,respectively, each of the three above-listed types of states ispresented in the below example “when” statement (the below also referredto herein as Example_2):

when RULEJNIT {set intra_session_state 0set::intra_module_state 0set::global::global_state 0}

Above Example_2 initializes each variable using the Tel “set” statement.The syntax of each of the above-initialized variables is explained,respectively, as follows:

An intra-session persistent variable “intra_session_state” is created,by simply introducing the variable's name.

An intra-module persistent variable “intra_module_state” is created, byprefixing the variable's name with a pair of colon symbols (i.e., ::).

A globally persistent variable “global_state” is created, by prefixingthe variable's name with two pairs of colon symbols surrounding thekeyword “global” (i.e., ::global::).

FIG. 2C shows an example internal structure for a CM collection such as201. Shown are three classification modules: 280, 281, and 282. Eachmodule is written in CML_Tcl. Although only three modules are shown, anysuitable number of classification modules can be included in acollection.

Each module begins with a statement, called Module Name, used to assignit a unique ID. This unique ID is also referred to herein as a“classification module ID” or “CMID.” Modules 280, 281, and 282 are eachgiven, respectively, the following CMID's: CM_ID_1, CM_ID_2, andCM_ID_3. Module 280 consists of three “when” statements, each triggered,in order from top to bottom, by the following event: RULEJNIT,CLIENT_DATA, and SERVER_DATA. The body of code, within each “when”statement, is not shown. Module 281 consists of two “when” statements:RULEJNIT and CLIENTDATA (once again, the body of code within each “when”statement is not shown). Module 282 does not need persistent state, inorder to accomplish its form of classification, and so a “when”statement triggered by RULEJNIT is not needed. Module 282 happens toinclude two “when” statements both triggered by the SERVER DATA event.

If, for example, module 280 were written by CableTV Inc. in CIVIL Tcl,in order to identify packets of its software CableTV_1, then suitableclassification rules for achieving CableTV Inc.'s goals are shown inFIG. 4B. Rules 480 and 481 of FIG. 4B are the same as rules 380 and 381of FIG. 3B, except the use of L4 Criteria field 231 is replaced withreferencing CM_ID_1 in L7 Criteria field 232.

Interpretation of a RULEJNIT event, when included as part of aclassification module, is accomplished by lines 12-29 of FIG. 5A. If thelatest-to-be-received packet p_1 is the first packet of a new session(tested by line 12), then any initialization that might be required (bya classification module operating within the context of the new session)can be performed.

Each classification module is iterated over (line 13). For the currentCM (called cm_1 in the pseudo-code), it is tested (line 14) for whetherit contains functionality triggered by a RULEJNIT type event. Forexample, if the classification module is written in CIVIL Tcl, suchfunctionality can be specified by a “when” statement that identifiesRULEJNIT as its triggering event. If RULEJNIT functionality is presentin cm J, each of the three above-listed types of state can be processed.The result of processing declarations of state can be represented bystate tables, such as State Tables 240 of FIG. 2A. FIG. 3C depicts anexample internal realization of Tables 240, with each of the threeabove-described types of state represented by a corresponding table:

Intra-Session Table 300: Each declaration of intra-session persistentstate can be represented by a row of this table. Each row can also bereferred to herein as an Intra-Session State Record. To access an itemof intrasession state (where the state itself is represented by field304 of Table 300), the following three fields must match:

SID 301

CM ID 302

Variable Identifier (or VID) 303

Intra-Module Table 310: Each declaration of intra-module persistentstate can be represented by a row of this table. Each row can also bereferred to herein as an Intra-Module State Record. To access an item ofintramodule state (where the state itself is represented by field 314 ofTable 310), the following two fields must match:

CMID312

Variable Identifier (VID) 313

Global Table 320: Each declaration of globally persistent state can berepresented by a row of this table. Each row can also be referred toherein as a Global State Record. To access an item of global_state(where the state itself is represented by field 324 of Table 320), onlythe following field need match:

Variable Identifier (VID) 323

Each state table has records added by one of the three following “for”loops of FIG. 5A:

lines 15-18: produces records for Intra-Session Table 300

lines 19-22: produces records for Intra-Module Table 310

lines 23-26: produces records for Global Table 320

Regardless of whether the latest packet p_1 represents a RULEJNIT typeevent, it needs to be tested for whether it is an event of typeCLIENT_DATA or SERVER_DATA. Testing, for these event types, is calledevent-detection. For the PACKET_RECEIVED procedure, event-detection isperformed by a call to event_detection (FIG. 5B, line 6).

By the time event_detection is executed, the following is known:

latest-received packet p_1 has been associated with a session s_1; and

any state needed by a classification module, to classify p_1 within thecontext of session s_1, has been initialized.

The pseudo-code of FIG. 5B, lines 9-28, presents an example process bywhich CLIENT_DATA and SERVER_DATA type events can be interpreted.

Each classification rule (such as a row of Rule Table 230 as shown ineither of FIG. 3B or 4B) is iterated over (by the “for” loop of line 9,FIG. 5B). For current rule r_1, it is tested for whether it uses aclassification module (line 10). (For example, rule 381 of FIG. 3B doesnot use a CM while rule 481 of FIG. 4B does.) If r_1 does use a CM, cm_1represents the module. Any pre-existing intra-session persistent state,under which cm_1 should be executed, is fetched (line 11). Tests arethen made, by each of lines 12-13 and 17-18 to determine, respectively,whether p_1 has caused a CLIENT_DATA or SERVER_DATA event.

Depending on which of these tests is satisfied, the appropriate portionof cm_1 is executed:

any CLIENT_DATA “when” statements are executed (line 15) if aCLIENT_DATA event has occurred; or

any SERVER_DATA “when” statements are executed (line 20) if aSERVER_DATA event has occurred.

During the execution of either type of “when” statement, variables canbe accessed that require intra-module persistent state or globallypersistent state (the possibility is mentioned in the comments of lines14 and 19). As discussed above, for each such variable, with a VID v_1,intra-module persistent state can be accessed with cm_1. CMID and v_1(applied to, for example, an Intra-Module Table 310) or globallypersistent state can be accessed with v_1 (applied to, for example,Global Table 320).

Even if a triggering event for a cm_1 of an r_1 has occurred, it may bethe case that cm_1 has already successfully executed for session s_1. Inthat case, it can be desirable to block cm_1 from executing again withrespect to the same session. This type of blocking, of repeatedexecution of a classification module with respect to a particularsession, can be referred to herein as “Blocking-type Execution.” Shownin square brackets, on each of lines 12-13 and 17-18, is the additionaltest that can be performed as part of adding Blocking-type Execution.These tests check for whether the “state under s_1.SID and cm_1.CMIDallows execution.”

For either a CLIENT_DATA or SERVER_DATA type event, if theclassification module executes successfully (tested by line 22), thefollowing is applicable:

Action portion of the current rule r_1 is performed (line 23). As hasbeen discussed above, the action of a Rule Record is to add a Traffic IDto the applicable session s_1.

If Blocking-type Execution is to be performed, state can be added, to anIntra-Session State Table record, indicating that, for session s_1, cm_1is not to be executed again. This operation is performed by line 24,shown in square brackets to indicate the optionality of Blocking-typeExecution. If an Intra-Session State Record does not already exist forthe combination s_1 and cm_1, it can be created by line 24 and then theappropriate indication, to block further execution, can be added.

In terms of the example CML_Tcl, the successful execution of a CM can bespecified by programming-in the execution of a particular statement. Anexample statement that could be executed is the following:

matchCML_Tcl

For the current rule r_1, if a test of it (by line 10) indicates that itdoes not use a classifier module, then r_1 can be tested for whether itsatisfies some other criteria. For example, as shown at line 27 of FIG.5B, r_1 can rely upon stateless criteria drawn from any combination ofL4 to L1 (these criteria having been discussed above, with respect tocolumn 231 of Rule Table 230 of FIG. 3B).

Flaying made sure that any necessary updates to current session s_1 havebeen performed, packet p_1 can be processed in accordance with theTraffic ID's of s_1. In the pseudo-code, such packet processing isperformed by invoking packet_process at line 30, FIG. 5B.

If p_1 is the last packet of a session (tested by line 1, FIG. 5C), thefollowing can be performed:

Session Record for that session can be removed (or flushed) from theSession Table (line 2).

A flush is performed for any state of the Intra-Session State Table,relating to the combination s_1 and cm_1 (line 3).

At this point, processing of latest-received packet p_1 is complete.

3 Multiple Collections

As discussed above in Section 1 (“Introduction”), the inventivetechniques presented herein focus on two main areas:

Improving the process by which a CM collection, as utilized by a trafficcontroller, is updated.

Enhancing the ability of a user, or small groups of users, to createclassification modules customized to the particular types of networktraffic they handle (please see Glossary for definition of “user”).

Having now covered major aspects of the latter of the two above-listedareas, this section focuses on the former. FIG. 2B is the same as FIG.2A, except for the following:

Rather than being limited to only having one CM collection loaded at anyone time, Control Engine 200 is shown as having up to two locations forstoring CM collections. The two locations are shown as: CM collection201, and CM collection 202. For each successive loading of an updatedcollection, the location to where it is written can alternate back andforth between collections 201 and 202. For example, Control Engine 200can start with just CM collection 201 loaded. The first time it isnecessary to load an updated collection, it can be loaded as CMcollection 202. The second time an updated collection is loaded, thelocation at which to load can alternate back to collection 201. Whileonly two collection-storing locations are shown in FIG. 2B, it can bereadily appreciated that any greater number of locations, as shown to beadvantageous for a particular situation, can be utilized.

A Session Table 250 is depicted, rather than 210. With regard to theinternal realization, the difference between Session Table 250 andSession Table 210 is shown by comparing FIGS. 3A and 4A. As can be seen,FIG. 4A depicts a Session Table 250 with an additional column 211(called a Collection ID or CID). The CID value, for a particular sessions_1, indicates the CM collection to be utilized when classifying s_1'spackets. For the current example, of only having up to two collectionsloaded, each CID need only be able to take one of two values, such as 0or 1.

FIGS. 6A-6G depict a pseudo-coded process similar to that of FIGS.5A-5B, except it has been modified to accommodate:

loading of an updated (or “new”) CM collection, while the pre-existing(or “old”) CM collection continues to be used; and

once the new CM collection has been loaded, transitioning, on asession-by-session basis that keeps a traffic controller active, fromthe old CM collection to the new CM collection; and

once the transitioning is completed, preparing for the possibility (atsome later time) of loading yet another updated CM collection.

FIGS. 6A-6G are organized as follows:

FIGS. 6C-6G depict a collection-switching version of the PACKET_RECEIVEDprocedure, that is a modified form of the procedure shown in FIGS.5A-5C.

FIG. 6B depicts a COLLECTION_LOADED procedure, that is activated eachtime an updated CM collection is loaded.

FIG. 6A presents a number of globally persistent variables that are tobe allocated and initialized, prior to beginning operation of either thePACKET_RECEIVED or COLLECTION LOADED procedures.

FIGS. 6A-6G are explained in conjunction with an example, that is alsoreferred to herein as Example_1. Example_1 begins with TrafficController 120 having loaded only a single CM collection 201, and withthe initializations of FIG. 6A having been performed. Theinitializations of FIG. 6A are as follows:

transitioning_flag (line 7): For the example presented herein, initiallyset to “false,” since only one CM collection has been loaded. Set to“true” from just after a replacement collection of classificationmodules has been loaded, and remains true until transition to thereplacement collection has been completed.

num_old_sessions (line 13): initialized to zero. When not transitioningbetween classification module collections, used to keep track of thenumber of sessions in session table. As soon as a new CM collection isloaded, this count can only decrement and, when it reaches zero, thetransitioning is complete.

num_new_sessions (line 18): initialized to zero. Only used whiletransitioning between classification module collections. Used to track:number of new sessions created since loading of new CM collection, andnumber of pre-existing sessions modified to refer to the new CMcollection.

old_collection (line 22): When not transitioning between classificationmodule collections, used for setting the CID value of new sessions.While transitioning, indicates the old CID value.

new_collection (line 23): Only used while transitioning betweenclassification module collections. Used for setting the CID value of newsessions and for resetting the CID value of pre-existing sessions.

Continuing with Example_1, until an updated CM collection is loaded, thePACKET_RECEIVED procedure of FIGS. 6C-6G operates as follows (a processsimilar to the PACKET_RECEIVED procedure of FIGS. 5A-5C):

Packets are received by the traffic controller (corresponds to atriggering of the PACKET RECEIVED event).

For each new session detected, a Session Record is added to SessionTable 250 (by call to session_detection).

A globally persistent count is kept (by num_old_sessions) of the numberof Session Records.

Each Session Record is given a CID value of 0. For example, SessionRecord 410 of FIG. 4A is the same as Session Record 370 of FIG. 3A,except it includes a Collection ID field with a current value of 0.

At some point in time, an updated CM collection is loaded, and isreferred to herein as CM collection 202. Each time an updated CMcollection is loaded, the COLLECTION_LOADED procedure of FIG. 6B isexecuted. It sets the globally persistent flag, transitioning_flag to“true” (line 4). This indicates that a transition is to be pursued,between the old CM collection (i.e., CM collection 201) and the updated(or “new”) CM collection (i.e., CM collection 202). Since no sessionshave yet been created under, or transferred to, the new CM collection,num_new_sessions has been properly initialized (by line 18, FIG. 6A) to0.

As each packet p_1 is received by the traffic controller, for so long asthe transitioning_flag remains true, any one of the following actionscan be done:

Any new sessions detected are given a Session Record with a CID valueof 1. This ensures that any further packets received, if part of a newsession, are classified by modules from the new CM collection. A countis kept (by num_new_sessions) of these new Session Records.

For a session s_1 that existed before loading of the new CM collection:

If the receipt of its latest packet p_1 represents an opportunity, whenthe session can be transitioned to the new CM collection, the followingis done:

s_1 's CID value is changed to 1

num_old_sessions is decremented, and

num_new_sessions is incremented.

If the receipt of its latest packet p_1 represents the end of s_1, thefollowing is done:

session is flushed from the Session Table

any intra-session state of s_1 is also flushed, and

num_old_sessions is decremented.

Each time num_old_sessions is decremented, as part of one of the twoabove-listed items, it is also tested for being 0. If it is, it is knownthat the transition from the old CM collection to the new CM collectionhas been completed. Preparation, for a possible future loading ofanother updated CM collection, is accomplished as follows:

transitioning_flag is set to false

num_old_sessions is set to the value of num_new_sessions, and

num_new_sessions is set to 0

Having presented an overview of the process, the pseudo-code of FIGS.6C-6G is explained in more detail as follows.

First, session-detection is performed at line 10, FIG. 6C. Thiscorresponds to line 10 of FIG. 5A. Next, if a new session is detected(FIG. 6C, line 12), it is handled by the code of FIG. 6C, line 13 toFIG. 6D, line 13. The code for handling new sessions corresponds tolines 13-29, of FIG. 5A. The differences are due to the need to handlethe transitioning state. The transitioning_flag is tested (line 13) forwhether it is set to “true”:

If it is set to “true,” the traffic controller is transitioning betweenCM collections and the following actions are taken:

The CID of the new session is set to point to the new CM collection byusing the value of new_collection (line 14).

To keep track of the sessions that are being classified by the new CMcollection, num_new_sessions is incremented (line 15).

Each classifier module to be tested, for whether it has a portiontriggered by the RULEJNIT event, is selected (see “for” loop of line 16)from the new CM collection.

Otherwise (see “else” of FIG. 6D, line 1):

The CID of the new session is set to point to the old CM collection byusing the value of old_collection (FIG. 6D, line 2).

To keep track of the sessions that are being classified by the old CMcollection, num_old_sessions is incremented (line 3).

Each classifier module to be tested, for whether it has a portiontriggered by the RULEJNIT event, is selected (see “for” loop of line 4)from the old CM collection.

Regardless of whether the latest packet p_1 represents the start of anew session, events of type CLIENT_DATA or SERVER_DATA are tested-fornext (see call to event_detection, line 21, FIG. 6D). This is the sametype of event-detection discussed in the previous section with respectto line 6 of FIG. 5B.

The Rule Records (such as those of FIG. 4B) are executed next. Thepseudocode for iterating over such rules (see FIG. 6E, lines 2-27) isthe similar to that discussed in the previous section (and shown at FIG.5B, lines 9-28). The difference is the addition of lines 4-8 of FIG. 6E,that test whether transitioning between CM collections is in effect. Ifthe traffic controller is in process of switching CM collections (testedfor by line 4), but the current session is still using the old CMcollection (tested for by line 5), then the cm_1 for r_1 is drawn fromthe old CM collection (as indicated by lines 5-6). Otherwise, the cm_1for r_1 is drawn from the new CM collection (by line 7). If the trafficcontroller is not in process of switching CM collections, the cm_1 forr_1 is drawn from the old CM collection (by line 9).

Packet processing is performed next, and the pseudo-code for that (seeFIG. 6E, line 29) is the same as discussed in the previous section (andshown at FIG. 5B, line 30).

The pseudo-code of FIG. 6F corresponds to the pseudo-code of FIG. 5C,lines 1-4. The pseudo-code of FIG. 5C (described in the previoussection) simply flushed the session from the Section Table, and thesession's intra-session state from the State Table, if the last packetof the session has been reached. The pseudo-code of FIG. 6F does flushthe session and its state (at line 2, FIG. 6F), but it also tests (atline 3) for whether transitioning, between CM collections, is still inprocess. If yes, the following steps are performed:

A test is made for whether this last packet of a session is also thefirst packet of the same session (line 4):

If yes, then the increment to num_new_sessions, just accomplished above(at FIG. 6C, line 15), needs to be undone (line 5, FIG. 6F).

Else, a test is made (line 8) for whether the session that just endedhad already been transitioned to the new CM collection:

If no, then the number of old sessions is decremented (line 9). If thismeans that all of the old sessions have either transitioned or ended(determined by testing num_old_sessions for zero at line 10):

transitioning is ended (by setting the transitioning_flag to “false” atline 11).

assigning the number of “new” sessions to the variable that keeps trackof the number of “old” sessions (line 12).

the number of “new” sessions is reset to zero (line 13).

The value used to represent the “old” CM collection (held byold_collection) is swapped (by the “swap_values” function of line 14)with the value used to represent the “new” CM collection (held bynew_collection).

Else, the session is a new session that ended before transitioningfinished, so only the number of new sessions needs to be decremented(line 16).

If the test of line 3 indicates that transitioning between CMcollections is not in process, the ending of a session simply means(other than flushing the session) that the number of old sessions isdecremented (line 19).

The pseudo-code of FIG. 6G addresses the case where the packet is notthe last of a session, but the session can be modified to utilize thenew CM collection. Specifically, a session subject to classification bythe old CM collection, can be modified if one of the following is truefor s_1 (both of which are tested at line 1, FIG. 6G):

has no saved state; or

(if optional Blocking-type Execution is desired) all saved stateindicates that further execution is not allowed.

If transitioning is in effect (tested by line 2), the following stepscan be performed:

The session, if it has not already been transitioned to the new CMcollection (a condition tested by line 3), can be transitioned.

The transitioning is accomplished by changing the session's CID to thatof the new CM collection (line 4), decrementing the number of oldsessions (line 5), and incrementing the number of new sessions (line 6).

If the transitioning of s_1 means that all old sessions have eithertransitioned or ended, as determined by comparing num_old_sessions tozero (FIG. 6G, line 7), transitioning can be ended. This is accomplishedby:

setting the transitioning_flag to “false” (line 8)

assigning the number of “new” sessions to the variable that keeps trackof the number of “old” sessions (line 9).

the number of “new” sessions is reset to zero (line 10).

The value used to represent the “old” CM collection (held byold_collection) is swapped (by the “swap_values” function of line 11)with the value used to represent the “new” CM collection (held bynew_collection).

4 Additional Information 4.1 Computing Equipment

With regard to any of the computing systems described herein, such asclient computers, a traffic controller, network equipment, and/or a datacenter, any type of non-volatile media (e.g., a hard drive, solid-statedrive, CD-ROM, or DVD) can be included.

Any reference above to information stored in a “table” can also beunderstood to refer to the use of a database, organized according to anyof the techniques known in the art, in accordance with the needs of aparticular application.

Computer systems that require interactivity with a user can be equippedwith any of the known user interface devices, as is appropriate for theparticular application, including, but not limited to: a monitor forvisual display (with or without touch screen capability), a keyboard,and a mouse (or any other form of pointing device).

In accordance with what is ordinarily known by those in the art, thecomputers specified herein contain computational hardware (e.g.,integrated circuits), and programmable memories (volatile and/ornon-volatile), of various types.

The kind of information described herein (such as data and/orinstructions), that is on computer-readable media and/or programmablememories, can be stored on computer-readable code devices embodiedtherein. A computer-readable code device can represent that portion of amemory in which a defined unit of information (such as a bit) can bestored and/or from which a defined unit of information can be retrieved.

5 Glossary of Selected Terms

A10 NETWORKS: A10 Networks, Inc., a California corporation with aprincipal place of business in San Jose, Calif., USA.

application:

Any system intended to have a particular area of applicability withrespect to at least one group of at least one or more users. Generallyhas at least some provision for interaction with its user group.

When regarded as primarily software, can be referred to as an“application program” or “application software.” In this case, is oftendefined by distinguishing it against programs involved in executing(e.g., a compiler or interpreter), or in managing the execution of(e.g., an operating system), an application program.

An application can contain one or more modules.

CID: Collection ID. Any value that uniquely identifies each CMcollection, in a group of two or more CM collections.

Classification module (or CM): a module that, as a result of itsapplication to a session, can assign a traffic type to one or more ofthe packets of the session.

CMID: Classification Module ID. Any value that uniquely identifies eachclassifier module, with respect to a classifier module collection.

CIVIL: Classification Module Language.

CIVIL Tcl: With regard to the products of A10 NETWORKS, the term“CML_Tcl” can be substituted by the term “AFLEX.” The term AFLEX can becapitalized in various ways, including, but in no way limited to, thefollowing: “aFleX,” “Aflex,” or “aflex.”

L1-L7: Refers to a layer of the Open Systems Interconnection (OSI)model, as developed by the International Organization forStandardization (ISO/IEC 7498-1). The OSI model is a way of providing astandardized characterization of the functions of a communicationssystem. Starting at the lowest level layer of L1 (also called the“physical layer”), each successive layer is intended to represent ahigher level of abstraction.

Loading or unloading: addresses the ability of a first system to becoupled (or otherwise connected) to a second system. After the “loading”of a first system is complete, it is able to interact with the secondsystem. If a first system is already “loaded,” with respect to a secondsystem, after “unloading” of the first system is complete, it is nolonger able to interact with the second system.

Module: anything that can be meaningfully regarded, with respect to somelarger system, as a distinct subsystem.

Pseudo-code: The pseudo-code presented herein is loosely based on the“Tel” programming language and CML_Tcl.

Session: as defined herein, refers to the entire process by which anytransfer of data, according to some protocol, begins, progresses, andcompletes. The term session, as used herein, encompasses data transfersunder “connectionless” protocols, such as UDP. In the case of UDP, theentire process of data transfer is completed with the transmission of asingle packet. For other protocols, such as TCP, a minimum of threepackets are needed simply to establish the beginning of a session.

SID: Session ID. Any value that uniquely identifies each session, asmanaged by a traffic controller.

System:

Can be comprised of hardware, software, or any combination of hardwareand software.

Unless indicated otherwise, the term “system” is understood as alsoreferring to anything that can be regarded as a subsystem.

Tel: a scripting language created by John Ousterhout in 1988. The namewas originally an acronym of “Tool Command Language.” Since 2000, Telhas been maintained by the Apache Software Foundation, a not-for-profitcorporation.

Traffic control: any technique or techniques by which the transmissionof packets within a network is controlled.

Traffic controller: any device that is capable of performing trafficcontrol. With regard to the products of A10 NETWORKS, a trafficcontroller can include, but is in no way limited to, the following: anApplication Bandwidth Manager of the EX Series.

Traffic type: a result of an effort to classify the one or more packetsthat comprise a session. Such types can typically be grouped into twocategories: application or content. Application and content arerelative: an application is a way in which to transmit content.

User: refers to the one or more persons that work together, for purposesof using a traffic controller, as a single administrative entity. Thus,a user of a traffic controller can include, but is not limited to, anyof the following: an individual person or an individual company. For thecase of a “user” that is an individual company, any of its employees orofficers, in the course of their utilization of a traffic controller,may be referred to herein as a “user.”

VID: Variable ID. Any symbol used to identify a variable in a CMLprogram.

While the invention has been described in conjunction with specificembodiments, it is evident that many alternatives, modifications andvariations will be apparent in light of the foregoing description.Accordingly, the invention is intended to embrace all such alternatives,modifications and variations as fall within the spirit and scope of theappended claims and equivalents.

What is claimed is:
 1. A method for dynamic network traffic control, themethod comprising: identifying, by a traffic controller, a first packetflowing from a source network device to a destination network device asa subject of traffic-type classification, the first packet beingproduced in response to an action by an end-user; identifying, by afirst collection of traffic classification modules of the trafficcontroller, a session identifier of the first packet, the sessionidentifier corresponding to a network session associated with the firstpacket; determining that the traffic controller is transitioning fromthe first collection of traffic classification modules to a secondcollection of traffic classification modules; determining that the firstpacket is an event of a first event type; and processing, the firstpacket in accordance with at least a default policy.
 2. The method ofclaim 1, wherein the determining that the first packet is an event ofthe first event type further comprises determining that the first packetis an initial packet of the first session.
 3. The method of claim 1,wherein the first event identifier is represented by an administrativeuser via a programming language statement of a RULE_INIT event.
 4. Themethod of claim 1, further comprising producing, as a result ofprocessing the first packet, an intra-session persistent state for thesecond collection of traffic classification modules.
 5. The method ofclaim 1, further comprising producing, as a result of processing thefirst packet, an intra-module persistent state for the second collectionof traffic classification modules.
 6. The method of claim 1, furthercomprising producing, as a result of processing the first packet, aglobally persistent state for the second collection of trafficclassification modules.
 7. The method of claim 1, further comprisingidentifying the first packet as being part of a pre-existing firstsession, in response to receipt of the first packet, if the first packetis not an initial packet to be received, by the traffic controller, withrespect to the first session.
 8. The method of claim 1, furthercomprising: classifying the first session as being of a first traffictype; and configuring the first traffic type, when applied to a session,to cause packets of that session to be processed in accordance with afirst policy.
 9. The method of claim 8, wherein the first policyguarantees a specific amount of bandwidth for forwarding traffic. 10.The method of claim 8, wherein the first policy performs one or more ofthe following: specifies a maximum amount of bandwidth for forwardingtraffic, marks a priority to be used for forwarded traffic, and causespackets not to be forwarded.
 11. The method of claim 1, wherein thedetermining that the first packet is an event of the first event typefurther comprises determining that the first packet is traveling from aclient to a server.
 12. The method of claim 1, wherein the first eventidentifier is represented by an administrative user via a programminglanguage statement of a CLIENT_EVENT.
 13. The method of claim 1, whereinthe determining that the first packet is an event of the first eventtype further comprises determining that the first packet is travelingfrom a server to a client.
 14. The method of claim 16, wherein the firstevent identifier is represented by an administrative user via aprogramming language statement of a SERVER_EVENT.
 15. The method ofclaim 1, wherein the second collection of traffic classification modulesis written in a classification module language.
 16. A system for dynamicnetwork traffic control, comprising: a traffic controller configured to:identify a first packet flowing from a source network device to adestination network device as a subject of traffic-type classification,the first packet being produced in response to an action by an end-user;determine that the first packet is an event of a first event type;process the first packet in accordance with at least a default policy;and a first collection of traffic classification modules of the trafficcontroller configured to: identify a session identifier of the firstpacket, the session identifier corresponding to a network sessionassociated with the first packet; and determine that the trafficcontroller is transitioning from the first collection of trafficclassification modules to a second collection of traffic classificationmodules.
 17. The system of claim 16, further comprising the secondcollection of traffic classification modules, wherein at least onemodule of the second collection of traffic classification modules iswritten by an administrative user of a client device using aclassification module language.
 18. The system of claim 16, wherein thedetermining that the first packet is an event of the first event typefurther comprises determining that the first packet is an initial packetof the first session.
 19. The system of claim 16, wherein thedetermining that the first packet is an event of the first event typefurther comprises determining that the first packet is traveling from aclient to a server.
 20. A system for dynamic network traffic control,comprising: a traffic controller configured to: identify a first packetflowing from a source network device to a destination network device asa subject of traffic-type classification, the first packet beingproduced in response to an action by an end-user; determine that thefirst packet is an event of a first event type; process the first packetin accordance with at least a default policy; and produce, as a resultof processing the first packet, at least one of an intra-sessionpersistent state for the second collection of traffic classificationmodules, an intra-module persistent state for the second collection oftraffic classification modules, and a globally persistent state for thesecond collection of traffic classification modules; a first collectionof traffic classification modules of the traffic controller configuredto: identify a session identifier of the first packet, the sessionidentifier corresponding to a network session associated with the firstpacket; and determine that the traffic controller is transitioning fromthe first collection of traffic classification modules to a secondcollection of traffic classification modules; and the second collectionof traffic classification modules, wherein at least one module of thesecond collection of traffic classification modules is written by anadministrative user of a client device using a classification modulelanguage.